#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <cstring> // for std::memcpy

// 定义一个模板结构体，用于封装C风格数组
template <typename T, std::size_t N>
struct ArrayWrapper {
    T data[N];

    // 默认构造函数
    ArrayWrapper() = default;

    // 允许通过一个C风格数组来构造
    ArrayWrapper(const T(&arr)[N]) {
        std::memcpy(data, arr, N * sizeof(T));
    }

    // 支持拷贝构造
    ArrayWrapper(const ArrayWrapper& other) {
        std::memcpy(data, other.data, N * sizeof(T));
    }

    // 支持赋值操作符
    ArrayWrapper& operator=(const ArrayWrapper& other) {
        if (this != &other) {
            std::memcpy(data, other.data, N * sizeof(T));
        }
        return *this;
    }
};

// 全局队列和同步机制
std::queue<ArrayWrapper<char, 64>> q;
std::mutex mtx;
std::condition_variable cv;

void dataReceiver() {
    while (true) {
        char arr[64] = {0};
        arr[0] = std::cin.get(); // 模拟接收到的数据
        {
            std::lock_guard<std::mutex> lock(mtx);
            q.push(ArrayWrapper<char, 64>(arr));
            std::cout << "Received data: " << arr[0] << std::endl;
        }

        cv.notify_one(); // 通知数据处理线程
        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // 模拟接收数据所需时间
    }
}

void dataProcessor() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);

        // 阻塞等待直到队列非空或接收线程完成
        cv.wait(lock, [] { return !q.empty(); });

        if (!q.empty()) {
            ArrayWrapper<char, 64> wrappedArray = q.front();
            q.pop();
            lock.unlock();

            // 处理数据
            std::cout << "Processed data: " << wrappedArray.data[0] << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 模拟处理数据所需时间
        }
    }
}

int main() {
    std::thread receiver(dataReceiver);
    std::thread processor(dataProcessor);

    receiver.join();
    processor.join();

    return 0;
}
